/**
 * 本地存储工具类
 * 用于管理图表数据的本地缓存
 */

class StorageManager {
  constructor() {
    this.CHART_LIST_KEY = 'chartLite_chartList';
    this.CHART_DATA_KEY = 'chartLite_chartData_';
    this.DRAFT_DATA_KEY = 'chartLite_draft_';
    this.APP_CONFIG_KEY = 'chartLite_config';
  }

  /**
   * 生成唯一的图表ID
   */
  generateChartId() {
    const timestamp = Date.now();
    const random = Math.random().toString(36).substr(2, 9);
    return `chart_${timestamp}_${random}`;
  }

  /**
   * 保存图表列表
   */
  saveChartList(chartList) {
    try {
      wx.setStorageSync(this.CHART_LIST_KEY, chartList);
      return true;
    } catch (error) {
      console.error('保存图表列表失败:', error);
      return false;
    }
  }

  /**
   * 获取图表列表
   */
  getChartList() {
    try {
      const chartList = wx.getStorageSync(this.CHART_LIST_KEY);
      return chartList || [];
    } catch (error) {
      console.error('获取图表列表失败:', error);
      return [];
    }
  }

  /**
   * 保存图表数据
   */
  saveChartData(chartId, data) {
    try {
      const key = this.CHART_DATA_KEY + chartId;
      wx.setStorageSync(key, {
        ...data,
        lastModified: new Date().toISOString(),
        version: '1.0'
      });
      return true;
    } catch (error) {
      console.error('保存图表数据失败:', error);
      return false;
    }
  }

  /**
   * 保存完整图表（包括列表信息和数据）
   */
  saveChart(chartData) {
    try {
      // 保存图表数据
      const dataSuccess = this.saveChartData(chartData.id, chartData);
      if (!dataSuccess) {
        return false;
      }

      // 更新图表列表
      const chartList = this.getChartList();
      const existingIndex = chartList.findIndex(chart => chart.id === chartData.id);
      
      const chartListItem = {
        id: chartData.id,
        title: chartData.title,
        subtitle: chartData.subtitle || '',
        type: chartData.type,
        typeName: this.getChartTypeName(chartData.type),
        lastModified: this.formatDate(new Date()),
        dataCount: chartData.dataCount || 0,
        createdAt: chartData.createdAt || new Date().toISOString()
      };

      if (existingIndex >= 0) {
        // 更新现有图表
        chartList[existingIndex] = chartListItem;
      } else {
        // 添加新图表
        chartList.push(chartListItem);
      }

      return this.saveChartList(chartList);
    } catch (error) {
      console.error('保存图表失败:', error);
      return false;
    }
  }

  /**
   * 获取图表数据
   */
  getChartData(chartId) {
    try {
      const key = this.CHART_DATA_KEY + chartId;
      const data = wx.getStorageSync(key);
      return data || null;
    } catch (error) {
      console.error('获取图表数据失败:', error);
      return null;
    }
  }

  /**
   * 获取单个图表信息
   */
  getChart(chartId) {
    return this.getChartData(chartId);
  }

  /**
   * 获取图表类型名称
   */
  getChartTypeName(type) {
    const typeNames = {
      'line': '折线图',
      'bar': '柱状图',
      'pie': '饼图',
      'scatter': '散点图',
      'radar': '雷达图',
      'heatmap': '热力图'
    };
    return typeNames[type] || '折线图';
  }

  /**
   * 保存草稿数据
   */
  saveDraft(chartId, data) {
    try {
      const key = this.DRAFT_DATA_KEY + chartId;
      wx.setStorageSync(key, {
        ...data,
        lastModified: new Date().toISOString(),
        isDraft: true
      });
      return true;
    } catch (error) {
      console.error('保存草稿失败:', error);
      return false;
    }
  }

  /**
   * 获取草稿数据
   */
  getDraft(chartId) {
    try {
      const key = this.DRAFT_DATA_KEY + chartId;
      const data = wx.getStorageSync(key);
      return data || null;
    } catch (error) {
      console.error('获取草稿失败:', error);
      return null;
    }
  }

  /**
   * 删除草稿数据
   */
  deleteDraft(chartId) {
    try {
      const key = this.DRAFT_DATA_KEY + chartId;
      wx.removeStorageSync(key);
      return true;
    } catch (error) {
      console.error('删除草稿失败:', error);
      return false;
    }
  }

  /**
   * 检查是否有草稿
   */
  hasDraft(chartId) {
    const draft = this.getDraft(chartId);
    return draft !== null;
  }

  /**
   * 格式化日期
   */
  formatDate(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    return `${year}-${month}-${day} ${hours}:${minutes}`;
  }

  /**
   * 删除图表数据
   */
  deleteChartData(chartId) {
    try {
      const key = this.CHART_DATA_KEY + chartId;
      wx.removeStorageSync(key);
      return true;
    } catch (error) {
      console.error('删除图表数据失败:', error);
      return false;
    }
  }

  /**
   * 复制图表数据
   */
  duplicateChartData(sourceChartId, targetChartId) {
    try {
      const sourceData = this.getChartData(sourceChartId);
      if (sourceData) {
        return this.saveChartData(targetChartId, {
          ...sourceData,
          lastModified: new Date().toISOString()
        });
      }
      return false;
    } catch (error) {
      console.error('复制图表数据失败:', error);
      return false;
    }
  }

  /**
   * 清理所有数据
   */
  clearAllData() {
    try {
      wx.clearStorageSync();
      return true;
    } catch (error) {
      console.error('清理数据失败:', error);
      return false;
    }
  }

  /**
   * 获取存储使用情况
   */
  getStorageInfo() {
    try {
      return wx.getStorageInfoSync();
    } catch (error) {
      console.error('获取存储信息失败:', error);
      return null;
    }
  }
}

// 创建全局实例
const storageManager = new StorageManager();

module.exports = storageManager;